package mpbe.estructura.secciones.hormigon_armado;

/*
 * Este codigo es software libre y se encuentra licenciado 
 * bajo los términos de la Licencia Pública General de GNU versión 3 
 * según se encuentra publicada por la Free Software Foundation.
 * http://www.gnu.org/licenses/gpl.html
 * 
 * Autor: Martin Pablo Bellanca <martin.bellanca@gmail.com>
 * web: http://mpbe.blogspot.com/
 */

import java.util.Iterator;
import java.util.Vector;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

import mpbe.estructura.secciones.hormigon_armado.contornos.SHContorno;

public class SHCargas {
	private Vector<SHCarga> cargas;
	private boolean guardar;
	private boolean recalcular;
	
	
	//-------------------------------------
	// Constructores
	//-------------------------------------
	public SHCargas() {
		cargas = new Vector<SHCarga>();
		cargas.add(new SHCarga(true));
		guardar = true;
		recalcular = true;
	}
	
	
	//-------------------------------------
	// Funciones de la seccion
	//-------------------------------------
	public SHCarga get_Carga_Activa(){
		SHCarga carga = new SHCarga();
		double Ms = 0;
		double Ns = 0;
		for (int cc=0; cc<cargas.size(); cc++){
			carga = new SHCarga();
			carga = cargas.get(cc);
			if (carga.activa) {
				Ns += carga.Ns;
				Ms += carga.Ms-carga.Ns*carga.posY;
			}
		}
		carga = new SHCarga();
		carga.Ns = Ns;
		carga.Ms = Ms;
		return carga;
	}
	
	
	//-------------------------------------
	// delegados de Guargar y recalcular
	//-------------------------------------
	public boolean isGuardar() {
		return guardar;
	}

	public void setGuardar(boolean guardar) {
		this.guardar = guardar;
	}

	public boolean isRecalcular() {
		return recalcular;
	}

	public void setRecalcular(boolean recalcular) {
		this.recalcular = recalcular;
	}
	
	
	//**********************************
	// Funciones de modificacion
	//**********************************
	public void mod_InvertirV(){
		// invierte el eje de referencia de las cargas
		if (cargas!=null) {
			SHCarga CC;
			for (int cc=0; cc<cargas.size(); cc++){
				CC = cargas.get(cc);
				CC.posY *= -1;
				CC.Ms *= -1;
			}
		}
	}
	
	//*****************************************************
	// Funciones JSON
	//*****************************************************
	public void put_JSON(JSONArray ja){
		JSONObject joa = new JSONObject();	
		cargas.clear();
		SHCarga cc;
		for (int ii=0; ii<ja.size(); ii++) {
			joa = (JSONObject) ja.get(ii);
			cc = new SHCarga();
			cc.put_JSON(joa);
			cargas.add(cc);
		}
	}
	public JSONArray get_JSONArray() {		
		JSONArray ja = new JSONArray();
		SHCarga cc = new SHCarga();
		for (int ii=0; ii<cargas.size(); ii++) {
			cc = cargas.get(ii);
			ja.add(cc.get_JSONObject());
		}
		return ja;
	}
	public String get_JSONString(int tab) {
		String res = tabs(tab+1)+"[\n";
		SHCarga cc = new SHCarga();
		for (int ii=0; ii<cargas.size(); ii++) {
			cc = cargas.get(ii);
			res += cc.get_JSONString(tab+1);
			if (ii==cargas.size()-1) res += "\n"+tabs(tab+1)+"],\n"; else res += ",\n";
		}
		return res;
	}
	
	private String tabs(int can) {
		String str = new String();
		for (int ii=0; ii<can; ii++) str += "   "; // \t
		return str;
	}
	
	//-------------------------------------
	// delegados de Carga
	//-------------------------------------
	public void add(int index, SHCarga element) {
		cargas.add(index, element);
		guardar = true;
		recalcular = true;
	}

	public boolean add(SHCarga e) {
		this.guardar = true;
		recalcular = true;
		return cargas.add(e);
	}

	public int capacity() {
		return cargas.capacity();
	}

	public void clear() {
		cargas.clear();
		this.guardar = true;
		recalcular = true;
	}

	public Object clone() {
		return cargas.clone();
	}

	public void copyInto(Vector <SHCarga> cargas)
	{
		cargas.clear();
		Iterator<SHCarga> it = this.cargas.iterator();
		SHCarga cc;
		while (it.hasNext()) {
			cc = new SHCarga();
			it.next().copyTo(cc);
			cargas.add(cc);
		} ;

	}
	
	public SHCarga firstElement() {
		return cargas.firstElement();
	}

	public SHCarga get(int index) {
		return cargas.get(index);
	}
	
	/**
	 * @return
	 * @uml.property  name="cargas"
	 */
	public Vector<SHCarga> getCargas() {
		return cargas;
	}
	
	/**
	 * @param cargas
	 * @uml.property  name="cargas"
	 */
	public void setCargas(Vector<SHCarga> cargas){
		this.cargas = cargas;
	}

	public int indexOf(Object o, int index) {
		return cargas.indexOf(o, index);
	}

	public int indexOf(Object o) {
		return cargas.indexOf(o);
	}

	public boolean isEmpty() {
		return cargas.isEmpty();
	}

	public Iterator<SHCarga> iterator() {
		return cargas.iterator();
	}

	public SHCarga lastElement() {
		return cargas.lastElement();
	}

	public int lastIndexOf(Object o, int index) {
		return cargas.lastIndexOf(o, index);
	}

	public int lastIndexOf(Object o) {
		return cargas.lastIndexOf(o);
	}

	public SHCarga remove(int index) {
		this.guardar = true;
		recalcular = true;
		return cargas.remove(index);
	}

	public boolean remove(Object o) {
		this.guardar = true;
		recalcular = true;
		return cargas.remove(o);
	}

	public SHCarga set(int index, SHCarga element) {
		this.guardar = true;
		recalcular = true;
		return cargas.set(index, element);
	}

	public void setSize(int newSize) {
		cargas.setSize(newSize);
	}

	public int size() {
		return cargas.size();
	}
	
	public String toString() {
		return cargas.toString();
	}

	
}
